home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / a_utils / expanded.lha / test_suite / testbasis.C < prev    next >
C/C++ Source or Header  |  1992-03-19  |  5KB  |  215 lines
  1. //
  2. // Linear-Affine-Projective Geometry Package
  3. //
  4. // testbasis.C
  5. //
  6. // $Header$
  7. //
  8. // William J.R. Longabaugh 
  9. // University of Washington
  10. //
  11. // Test programs for the linear-affine-projective geometry
  12. // package described in William J.R. Longabaugh, "An Expanded
  13. // System for Coordinate-Free Geometric Programming", Master's 
  14. // thesis, University of Washington, 1992.
  15. //
  16. // Copyright (c) 1992, William J.R. Longabaugh
  17. //   Copying, use and development for non-commercial purposes permitted.
  18. //   All rights for commercial use reserved.
  19. //   This software is unsupported and without warranty; it is
  20. //   provided "as is".
  21. //
  22. // ***********************************************************************
  23.  
  24. #include "Lap.h"
  25. #include <math.h>
  26.  
  27. extern void test1(void);
  28. extern void test2(void);
  29. extern void test3(void);
  30.  
  31. // ***********************************************************************
  32.  
  33. int main(void)
  34. {
  35.   test1();
  36.   test2();
  37.   test3();
  38.   return (0);
  39. }
  40.  
  41.  
  42. // ***********************************************************************
  43. // Build different bases, access elements, use to get coordinates:
  44.  
  45. void test1(void)
  46. {
  47.   cout << "ENTERING TEST1\n";
  48.   VSpace v("Test vector space", 3, TRUE);
  49.   ASpace a("Test affine space", 2, TRUE);
  50.   PSpace p;
  51.   p = PSpace("Test projective space", v, a);
  52.  
  53. // Create different kinds of bases:
  54.  
  55.   VBasis bas = v.StdBasis();
  56.   Frame  fra = a.StdBasis();
  57.   HFrame hfra;
  58.   hfra = p.StdBasis();
  59.  
  60.   Vector v1(bas, ScalarList(1.4, 2.3, 5.6));
  61.   Vector v2(bas, ScalarList(2.4, 0.3, 9.5));
  62.   AVector av1(fra, ScalarList(2.5, 3.6, 0.0));
  63.   AVector av2(fra, ScalarList(-4.6, 1.1, 0.0));
  64.   APoint a1(fra, ScalarList(3.6, -4.5, 1.0));
  65.   PPoint p1(hfra, ScalarList(2.1, 4.3, 7.2));
  66.   PPoint p2;
  67.   p2 = PPoint(hfra, ScalarList(5.6, 8.7, 1.3));
  68.  
  69.   VBasis b1("test vbasis", v, GeObList(v1, av1, p2));
  70.   Frame f1("test frame", a, GeObList(av1, av2, p1));
  71.   Simplex s1("test simplex", a, GeObList(p1, a1, p2));
  72.   HFrame h1;
  73.   h1 = HFrame("test proj frame", p, GeObList(p1, VectorEC(v2), a1, p2));
  74.   cout << b1;
  75.   cout << f1;
  76.   cout << s1;
  77.   cout << h1;
  78.  
  79. // Converting simplices/frames:
  80.  
  81.   Simplex s2(f1);
  82.   Frame f2(s1, 2);
  83.   cout << s2;
  84.   cout << f2;
  85.  
  86. // Accessing elements of a basis:
  87.  
  88.   GeOb ov = b1[0];
  89.   cout << ov;
  90.   ov = b1[2];
  91.   cout << ov;
  92.  
  93.   GeOb oav = f1[0];
  94.   cout << oav;
  95.   oav = f1[1];
  96.   cout << oav;
  97.   GeOb oap = f1[2];
  98.   cout << oap;
  99.  
  100.   oap = s1[0];
  101.   cout << oap;
  102.   oap = s1[2];
  103.   cout << oap;
  104.  
  105.   GeOb opp = h1[0];
  106.   cout << opp;
  107.   opp = h1[3];
  108.   cout << opp;
  109.  
  110. // Using a basis to get coordinates:
  111.  
  112.   ScalarList listo = b1(p2);
  113.   cout << listo;
  114.  
  115.   PPoint ptst1 = a1;
  116.   listo = f1(ptst1);
  117.   cout << listo;
  118.   listo = s1(ptst1);
  119.   cout << listo;
  120.  
  121.   Vector tst1 = av1;
  122.   listo = f1(tst1);
  123.   cout << listo;
  124.   listo = s1(tst1);
  125.   cout << listo;
  126.  
  127.   tst1 = a1;
  128.   listo = h1(tst1);
  129.   cout << listo;
  130.   listo = h1(p2);
  131.   cout << listo;
  132. }
  133.  
  134. // ***********************************************************************
  135. // Build bases using vector and point tuples:
  136.  
  137. void test2(void)
  138. {
  139.   cout << "ENTERING TEST2\n";
  140.   VSpace v("Test vector space", 3, TRUE);
  141.   ASpace a("Test affine space", TRUE, v);
  142.   VSpace t = a.GetSpace(TANGENT);
  143.  
  144.   ASpace ca("Cartesian aspace", SpaceList(a, a, a), FALSE);
  145.   VSpace cv1("Cartesian vspace1", SpaceList(v, t, t), FALSE);
  146.   VSpace cv2("Cartesian vspace2", SpaceList(t, v, v), FALSE);
  147.   VSpace cv3("Cartesian vspace3", SpaceList(v, v), FALSE);
  148.  
  149.   Frame fra = a.StdBasis();
  150.   APoint a1(fra, ScalarList(3.6, -4.5, 1.0));
  151.   APoint a2(fra, ScalarList(2.5, 7.8, 1.0));
  152.   APoint a3(fra, ScalarList(-1.1, 6.3, 1.0));
  153.  
  154.   APoint ptup(ca, GeObList(a1, a2, a3));
  155.   Simplex simp("Test tuple simplex", ptup);
  156.   cout << simp;
  157.  
  158.   VBasis bas = v.StdBasis();
  159.   Vector v1(bas, ScalarList(1.4, 2.3, 5.6));
  160.   Vector v2(bas, ScalarList(3.6, -4.5, 0.0));
  161.   Vector v3(bas, ScalarList(2.4, 0.3, 0.0));
  162.   AVector av1(fra, ScalarList(2.4, 3.3, 0.0));
  163.   AVector av2(fra, ScalarList(1.1, 7.8, 0.0));
  164.  
  165.   Vector vtup1(cv1, GeObList(v1, av1, av2));
  166.   VBasis vbas1("Test tuple basis 1", vtup1);
  167.   cout << vbas1;
  168.  
  169.   Vector vtup2(cv2, GeObList(av1, v1, v2));
  170.   VBasis vbas2("Test tuple basis 2", vtup2);
  171.   cout << vbas2;
  172.  
  173.   Vector vtup3(cv3, GeObList(v2, v3));
  174.   VBasis vbas3("Test tuple basis 3", vtup3);
  175.   cout << vbas3;
  176. }
  177.  
  178. // ***********************************************************************
  179. // Creation of a dual basis:
  180.  
  181. void test3(void)
  182. {
  183.   cout << "ENTERING TEST3\n";
  184.   VSpace v("test vspace", 3, TRUE);
  185.   VBasis bas = v.StdBasis();
  186.   Vector v1(bas, ScalarList(1.4, 2.3, 5.6));
  187.   Vector v2(bas, ScalarList(3.6, -4.5, 7.8));
  188.   Vector v3(bas, ScalarList(2.4, 0.3, 9.5));
  189.   VBasis b1("test basis", v, GeObList(v1, v2, v3));
  190.   cout << b1;
  191.   VBasis du = b1.Dual();
  192.   cout << du;
  193.   Vector vd(du, ScalarList(1.4, 2.3, 5.6));
  194.   cout << vd;
  195.   for (int i = 0; i < 3; i++) {
  196.     for (int j = 0; j < 3; j++) {
  197.       cout << b1[i].Apply(du[j]) << " ";
  198.     }
  199.     cout << "\n";
  200.   }
  201.   cout << "\n" << vd.Apply(v1) << "\n";
  202. }
  203.  
  204. // ***********************************************************************
  205.  
  206.  
  207.  
  208.  
  209.  
  210.  
  211.  
  212.  
  213.  
  214.  
  215.